// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.wms.order;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.WmsOrder;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(WmsOrder.class)
@Setter
@Getter
public class WmsOrderSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "WmsOrder".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("sid", "si");
    map.put("wid", "w");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：WmsOrder/WmsOrder
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 所属订单管理
   */
  private Long parentNavSellOrder;

  /**
   * 最小所属订单管理
   */
  private Long parentNavSellOrderMin;

  /**
   * 最大所属订单管理
   */
  private Long parentNavSellOrderMax;

  /**
   * 所属订单管理 比较(eq)
   */
  private Long parentNavSellOrderEq;
  /**
   * 所属订单管理 比较(neq)
   */
  private Long parentNavSellOrderNeq;
  /**
   * 所属订单管理 比较(gt)
   */
  private Long parentNavSellOrderGt;
  /**
   * 所属订单管理 比较(gte)
   */
  private Long parentNavSellOrderGte;
  /**
   * 所属订单管理 比较(lt)
   */
  private Long parentNavSellOrderLt;
  /**
   * 所属订单管理 比较(lte)
   */
  private Long parentNavSellOrderLte;
  /**
   * 所属订单管理 比较(contains)
   */
  private Long parentNavSellOrderContains;
  /**
   * 所属订单管理 比较(notcontains)
   */
  private Long parentNavSellOrderNotcontains;
  /**
   * 所属订单管理 比较(startswith)
   */
  private Long parentNavSellOrderStartswith;
  /**
   * 所属订单管理 比较(endswith)
   */
  private Long parentNavSellOrderEndswith;
  /**
   * 所属订单管理 比较(isnull)
   */
  private Boolean parentNavSellOrderIsnull;
  /**
   * 所属订单管理 比较(isnotnull)
   */
  private Boolean parentNavSellOrderIsnotnull;

  /**
   * 销售出库单号(模糊搜索)
   */
  private String woNumber;

  /**
   * 销售出库单号 比较(eq)
   */
  private String woNumberEq;
  /**
   * 销售出库单号 比较(neq)
   */
  private String woNumberNeq;
  /**
   * 销售出库单号 比较(gt)
   */
  private String woNumberGt;
  /**
   * 销售出库单号 比较(gte)
   */
  private String woNumberGte;
  /**
   * 销售出库单号 比较(lt)
   */
  private String woNumberLt;
  /**
   * 销售出库单号 比较(lte)
   */
  private String woNumberLte;
  /**
   * 销售出库单号 比较(contains)
   */
  private String woNumberContains;
  /**
   * 销售出库单号 比较(notcontains)
   */
  private String woNumberNotcontains;
  /**
   * 销售出库单号 比较(startswith)
   */
  private String woNumberStartswith;
  /**
   * 销售出库单号 比较(endswith)
   */
  private String woNumberEndswith;
  /**
   * 销售出库单号 比较(isnull)
   */
  private Boolean woNumberIsnull;
  /**
   * 销售出库单号 比较(isnotnull)
   */
  private Boolean woNumberIsnotnull;

  /**
   * 销售出库单号(精确搜索)
   */
  private List<String> woNumberInList;

  /**
   * 系统单号(模糊搜索)
   */
  private String orderNumber;

  /**
   * 系统单号 比较(eq)
   */
  private String orderNumberEq;
  /**
   * 系统单号 比较(neq)
   */
  private String orderNumberNeq;
  /**
   * 系统单号 比较(gt)
   */
  private String orderNumberGt;
  /**
   * 系统单号 比较(gte)
   */
  private String orderNumberGte;
  /**
   * 系统单号 比较(lt)
   */
  private String orderNumberLt;
  /**
   * 系统单号 比较(lte)
   */
  private String orderNumberLte;
  /**
   * 系统单号 比较(contains)
   */
  private String orderNumberContains;
  /**
   * 系统单号 比较(notcontains)
   */
  private String orderNumberNotcontains;
  /**
   * 系统单号 比较(startswith)
   */
  private String orderNumberStartswith;
  /**
   * 系统单号 比较(endswith)
   */
  private String orderNumberEndswith;
  /**
   * 系统单号 比较(isnull)
   */
  private Boolean orderNumberIsnull;
  /**
   * 系统单号 比较(isnotnull)
   */
  private Boolean orderNumberIsnotnull;

  /**
   * 系统单号(精确搜索)
   */
  private List<String> orderNumberInList;

  /**
   * 波次号(模糊搜索)
   */
  private String waveOrder;

  /**
   * 波次号 比较(eq)
   */
  private String waveOrderEq;
  /**
   * 波次号 比较(neq)
   */
  private String waveOrderNeq;
  /**
   * 波次号 比较(gt)
   */
  private String waveOrderGt;
  /**
   * 波次号 比较(gte)
   */
  private String waveOrderGte;
  /**
   * 波次号 比较(lt)
   */
  private String waveOrderLt;
  /**
   * 波次号 比较(lte)
   */
  private String waveOrderLte;
  /**
   * 波次号 比较(contains)
   */
  private String waveOrderContains;
  /**
   * 波次号 比较(notcontains)
   */
  private String waveOrderNotcontains;
  /**
   * 波次号 比较(startswith)
   */
  private String waveOrderStartswith;
  /**
   * 波次号 比较(endswith)
   */
  private String waveOrderEndswith;
  /**
   * 波次号 比较(isnull)
   */
  private Boolean waveOrderIsnull;
  /**
   * 波次号 比较(isnotnull)
   */
  private Boolean waveOrderIsnotnull;

  /**
   * 波次号(精确搜索)
   */
  private List<String> waveOrderInList;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 平台单号(模糊搜索)
   */
  private String platformOrderNo;

  /**
   * 平台单号 比较(eq)
   */
  private String platformOrderNoEq;
  /**
   * 平台单号 比较(neq)
   */
  private String platformOrderNoNeq;
  /**
   * 平台单号 比较(gt)
   */
  private String platformOrderNoGt;
  /**
   * 平台单号 比较(gte)
   */
  private String platformOrderNoGte;
  /**
   * 平台单号 比较(lt)
   */
  private String platformOrderNoLt;
  /**
   * 平台单号 比较(lte)
   */
  private String platformOrderNoLte;
  /**
   * 平台单号 比较(contains)
   */
  private String platformOrderNoContains;
  /**
   * 平台单号 比较(notcontains)
   */
  private String platformOrderNoNotcontains;
  /**
   * 平台单号 比较(startswith)
   */
  private String platformOrderNoStartswith;
  /**
   * 平台单号 比较(endswith)
   */
  private String platformOrderNoEndswith;
  /**
   * 平台单号 比较(isnull)
   */
  private Boolean platformOrderNoIsnull;
  /**
   * 平台单号 比较(isnotnull)
   */
  private Boolean platformOrderNoIsnotnull;

  /**
   * 平台单号(精确搜索)
   */
  private List<String> platformOrderNoInList;

  /**
   * 物流服务商(模糊搜索)
   */
  private String logisticsProviderId;

  /**
   * 物流服务商 比较(eq)
   */
  private String logisticsProviderIdEq;
  /**
   * 物流服务商 比较(neq)
   */
  private String logisticsProviderIdNeq;
  /**
   * 物流服务商 比较(gt)
   */
  private String logisticsProviderIdGt;
  /**
   * 物流服务商 比较(gte)
   */
  private String logisticsProviderIdGte;
  /**
   * 物流服务商 比较(lt)
   */
  private String logisticsProviderIdLt;
  /**
   * 物流服务商 比较(lte)
   */
  private String logisticsProviderIdLte;
  /**
   * 物流服务商 比较(contains)
   */
  private String logisticsProviderIdContains;
  /**
   * 物流服务商 比较(notcontains)
   */
  private String logisticsProviderIdNotcontains;
  /**
   * 物流服务商 比较(startswith)
   */
  private String logisticsProviderIdStartswith;
  /**
   * 物流服务商 比较(endswith)
   */
  private String logisticsProviderIdEndswith;
  /**
   * 物流服务商 比较(isnull)
   */
  private Boolean logisticsProviderIdIsnull;
  /**
   * 物流服务商 比较(isnotnull)
   */
  private Boolean logisticsProviderIdIsnotnull;

  /**
   * 物流服务商(精确搜索)
   */
  private List<String> logisticsProviderIdInList;

  /**
   * 物流方式(模糊搜索)
   */
  private String logisticsTypeId;

  /**
   * 物流方式 比较(eq)
   */
  private String logisticsTypeIdEq;
  /**
   * 物流方式 比较(neq)
   */
  private String logisticsTypeIdNeq;
  /**
   * 物流方式 比较(gt)
   */
  private String logisticsTypeIdGt;
  /**
   * 物流方式 比较(gte)
   */
  private String logisticsTypeIdGte;
  /**
   * 物流方式 比较(lt)
   */
  private String logisticsTypeIdLt;
  /**
   * 物流方式 比较(lte)
   */
  private String logisticsTypeIdLte;
  /**
   * 物流方式 比较(contains)
   */
  private String logisticsTypeIdContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private String logisticsTypeIdNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private String logisticsTypeIdStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private String logisticsTypeIdEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean logisticsTypeIdIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean logisticsTypeIdIsnotnull;

  /**
   * 物流方式(精确搜索)
   */
  private List<String> logisticsTypeIdInList;

  /**
   * 标签(模糊搜索)
   */
  private String tagNames;

  /**
   * 标签 比较(eq)
   */
  private String tagNamesEq;
  /**
   * 标签 比较(neq)
   */
  private String tagNamesNeq;
  /**
   * 标签 比较(gt)
   */
  private String tagNamesGt;
  /**
   * 标签 比较(gte)
   */
  private String tagNamesGte;
  /**
   * 标签 比较(lt)
   */
  private String tagNamesLt;
  /**
   * 标签 比较(lte)
   */
  private String tagNamesLte;
  /**
   * 标签 比较(contains)
   */
  private String tagNamesContains;
  /**
   * 标签 比较(notcontains)
   */
  private String tagNamesNotcontains;
  /**
   * 标签 比较(startswith)
   */
  private String tagNamesStartswith;
  /**
   * 标签 比较(endswith)
   */
  private String tagNamesEndswith;
  /**
   * 标签 比较(isnull)
   */
  private Boolean tagNamesIsnull;
  /**
   * 标签 比较(isnotnull)
   */
  private Boolean tagNamesIsnotnull;

  /**
   * 标签(精确搜索)
   */
  private List<String> tagNamesInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String sidShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String sidShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String sidShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String sidShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String sidShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String sidShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String sidShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String sidShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String sidShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String sidShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean sidShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean sidShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> sidInList;

  /**
   * 站点名称(模糊搜索)
   */
  private String siteText;

  /**
   * 站点名称 比较(eq)
   */
  private String siteTextEq;
  /**
   * 站点名称 比较(neq)
   */
  private String siteTextNeq;
  /**
   * 站点名称 比较(gt)
   */
  private String siteTextGt;
  /**
   * 站点名称 比较(gte)
   */
  private String siteTextGte;
  /**
   * 站点名称 比较(lt)
   */
  private String siteTextLt;
  /**
   * 站点名称 比较(lte)
   */
  private String siteTextLte;
  /**
   * 站点名称 比较(contains)
   */
  private String siteTextContains;
  /**
   * 站点名称 比较(notcontains)
   */
  private String siteTextNotcontains;
  /**
   * 站点名称 比较(startswith)
   */
  private String siteTextStartswith;
  /**
   * 站点名称 比较(endswith)
   */
  private String siteTextEndswith;
  /**
   * 站点名称 比较(isnull)
   */
  private Boolean siteTextIsnull;
  /**
   * 站点名称 比较(isnotnull)
   */
  private Boolean siteTextIsnotnull;

  /**
   * 站点名称(精确搜索)
   */
  private List<String> siteTextInList;

  /**
   * 平台名称(模糊搜索)
   */
  private String platformName;

  /**
   * 平台名称 比较(eq)
   */
  private String platformNameEq;
  /**
   * 平台名称 比较(neq)
   */
  private String platformNameNeq;
  /**
   * 平台名称 比较(gt)
   */
  private String platformNameGt;
  /**
   * 平台名称 比较(gte)
   */
  private String platformNameGte;
  /**
   * 平台名称 比较(lt)
   */
  private String platformNameLt;
  /**
   * 平台名称 比较(lte)
   */
  private String platformNameLte;
  /**
   * 平台名称 比较(contains)
   */
  private String platformNameContains;
  /**
   * 平台名称 比较(notcontains)
   */
  private String platformNameNotcontains;
  /**
   * 平台名称 比较(startswith)
   */
  private String platformNameStartswith;
  /**
   * 平台名称 比较(endswith)
   */
  private String platformNameEndswith;
  /**
   * 平台名称 比较(isnull)
   */
  private Boolean platformNameIsnull;
  /**
   * 平台名称 比较(isnotnull)
   */
  private Boolean platformNameIsnotnull;

  /**
   * 平台名称(精确搜索)
   */
  private List<String> platformNameInList;

  /**
   * 最早出库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveredAtStart;

  /**
   * 最晚出库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveredAtEnd;

  /**
   * 出库时间 比较(eq)
   */
  private Date deliveredAtEq;
  /**
   * 出库时间 比较(neq)
   */
  private Date deliveredAtNeq;
  /**
   * 出库时间 比较(gt)
   */
  private Date deliveredAtGt;
  /**
   * 出库时间 比较(gte)
   */
  private Date deliveredAtGte;
  /**
   * 出库时间 比较(lt)
   */
  private Date deliveredAtLt;
  /**
   * 出库时间 比较(lte)
   */
  private Date deliveredAtLte;
  /**
   * 出库时间 比较(contains)
   */
  private Date deliveredAtContains;
  /**
   * 出库时间 比较(notcontains)
   */
  private Date deliveredAtNotcontains;
  /**
   * 出库时间 比较(startswith)
   */
  private Date deliveredAtStartswith;
  /**
   * 出库时间 比较(endswith)
   */
  private Date deliveredAtEndswith;
  /**
   * 出库时间 比较(isnull)
   */
  private Boolean deliveredAtIsnull;
  /**
   * 出库时间 比较(isnotnull)
   */
  private Boolean deliveredAtIsnotnull;

  /**
   * 发货人(模糊搜索)
   */
  private String deliverer;

  /**
   * 发货人 比较(eq)
   */
  private String delivererEq;
  /**
   * 发货人 比较(neq)
   */
  private String delivererNeq;
  /**
   * 发货人 比较(gt)
   */
  private String delivererGt;
  /**
   * 发货人 比较(gte)
   */
  private String delivererGte;
  /**
   * 发货人 比较(lt)
   */
  private String delivererLt;
  /**
   * 发货人 比较(lte)
   */
  private String delivererLte;
  /**
   * 发货人 比较(contains)
   */
  private String delivererContains;
  /**
   * 发货人 比较(notcontains)
   */
  private String delivererNotcontains;
  /**
   * 发货人 比较(startswith)
   */
  private String delivererStartswith;
  /**
   * 发货人 比较(endswith)
   */
  private String delivererEndswith;
  /**
   * 发货人 比较(isnull)
   */
  private Boolean delivererIsnull;
  /**
   * 发货人 比较(isnotnull)
   */
  private Boolean delivererIsnotnull;

  /**
   * 发货人(精确搜索)
   */
  private List<String> delivererInList;

  /**
   * 国家(模糊搜索)
   */
  private String targetCountry;

  /**
   * 国家 比较(eq)
   */
  private String targetCountryEq;
  /**
   * 国家 比较(neq)
   */
  private String targetCountryNeq;
  /**
   * 国家 比较(gt)
   */
  private String targetCountryGt;
  /**
   * 国家 比较(gte)
   */
  private String targetCountryGte;
  /**
   * 国家 比较(lt)
   */
  private String targetCountryLt;
  /**
   * 国家 比较(lte)
   */
  private String targetCountryLte;
  /**
   * 国家 比较(contains)
   */
  private String targetCountryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String targetCountryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String targetCountryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String targetCountryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean targetCountryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean targetCountryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> targetCountryInList;

  /**
   * 收件人税号(模糊搜索)
   */
  private String recipientTaxNo;

  /**
   * 收件人税号 比较(eq)
   */
  private String recipientTaxNoEq;
  /**
   * 收件人税号 比较(neq)
   */
  private String recipientTaxNoNeq;
  /**
   * 收件人税号 比较(gt)
   */
  private String recipientTaxNoGt;
  /**
   * 收件人税号 比较(gte)
   */
  private String recipientTaxNoGte;
  /**
   * 收件人税号 比较(lt)
   */
  private String recipientTaxNoLt;
  /**
   * 收件人税号 比较(lte)
   */
  private String recipientTaxNoLte;
  /**
   * 收件人税号 比较(contains)
   */
  private String recipientTaxNoContains;
  /**
   * 收件人税号 比较(notcontains)
   */
  private String recipientTaxNoNotcontains;
  /**
   * 收件人税号 比较(startswith)
   */
  private String recipientTaxNoStartswith;
  /**
   * 收件人税号 比较(endswith)
   */
  private String recipientTaxNoEndswith;
  /**
   * 收件人税号 比较(isnull)
   */
  private Boolean recipientTaxNoIsnull;
  /**
   * 收件人税号 比较(isnotnull)
   */
  private Boolean recipientTaxNoIsnotnull;

  /**
   * 收件人税号(精确搜索)
   */
  private List<String> recipientTaxNoInList;

  /**
   * 运单号(模糊搜索)
   */
  private String waybillNo;

  /**
   * 运单号 比较(eq)
   */
  private String waybillNoEq;
  /**
   * 运单号 比较(neq)
   */
  private String waybillNoNeq;
  /**
   * 运单号 比较(gt)
   */
  private String waybillNoGt;
  /**
   * 运单号 比较(gte)
   */
  private String waybillNoGte;
  /**
   * 运单号 比较(lt)
   */
  private String waybillNoLt;
  /**
   * 运单号 比较(lte)
   */
  private String waybillNoLte;
  /**
   * 运单号 比较(contains)
   */
  private String waybillNoContains;
  /**
   * 运单号 比较(notcontains)
   */
  private String waybillNoNotcontains;
  /**
   * 运单号 比较(startswith)
   */
  private String waybillNoStartswith;
  /**
   * 运单号 比较(endswith)
   */
  private String waybillNoEndswith;
  /**
   * 运单号 比较(isnull)
   */
  private Boolean waybillNoIsnull;
  /**
   * 运单号 比较(isnotnull)
   */
  private Boolean waybillNoIsnotnull;

  /**
   * 运单号(精确搜索)
   */
  private List<String> waybillNoInList;

  /**
   * 跟踪号(模糊搜索)
   */
  private String trackingNo;

  /**
   * 跟踪号 比较(eq)
   */
  private String trackingNoEq;
  /**
   * 跟踪号 比较(neq)
   */
  private String trackingNoNeq;
  /**
   * 跟踪号 比较(gt)
   */
  private String trackingNoGt;
  /**
   * 跟踪号 比较(gte)
   */
  private String trackingNoGte;
  /**
   * 跟踪号 比较(lt)
   */
  private String trackingNoLt;
  /**
   * 跟踪号 比较(lte)
   */
  private String trackingNoLte;
  /**
   * 跟踪号 比较(contains)
   */
  private String trackingNoContains;
  /**
   * 跟踪号 比较(notcontains)
   */
  private String trackingNoNotcontains;
  /**
   * 跟踪号 比较(startswith)
   */
  private String trackingNoStartswith;
  /**
   * 跟踪号 比较(endswith)
   */
  private String trackingNoEndswith;
  /**
   * 跟踪号 比较(isnull)
   */
  private Boolean trackingNoIsnull;
  /**
   * 跟踪号 比较(isnotnull)
   */
  private Boolean trackingNoIsnotnull;

  /**
   * 跟踪号(精确搜索)
   */
  private List<String> trackingNoInList;

  /**
   * 仓库
   */
  private Long wid;

  /**
   * 仓库 比较(eq)
   */
  private Long widEq;
  /**
   * 仓库 比较(neq)
   */
  private Long widNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long widGt;
  /**
   * 仓库 比较(gte)
   */
  private Long widGte;
  /**
   * 仓库 比较(lt)
   */
  private Long widLt;
  /**
   * 仓库 比较(lte)
   */
  private Long widLte;
  /**
   * 仓库 比较(contains)
   */
  private Long widContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long widNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long widStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long widEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean widIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean widIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String widNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String widNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String widNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String widNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String widNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String widNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String widNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String widNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String widNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String widNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean widNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean widNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> widInList;

  /**
   * 预估运费
   */
  private java.math.BigDecimal logisticsEstimatedFreight;

  /**
   * 最小预估运费
   */
  private java.math.BigDecimal logisticsEstimatedFreightMin;

  /**
   * 最大预估运费
   */
  private java.math.BigDecimal logisticsEstimatedFreightMax;

  /**
   * 预估运费 比较(eq)
   */
  private java.math.BigDecimal logisticsEstimatedFreightEq;
  /**
   * 预估运费 比较(neq)
   */
  private java.math.BigDecimal logisticsEstimatedFreightNeq;
  /**
   * 预估运费 比较(gt)
   */
  private java.math.BigDecimal logisticsEstimatedFreightGt;
  /**
   * 预估运费 比较(gte)
   */
  private java.math.BigDecimal logisticsEstimatedFreightGte;
  /**
   * 预估运费 比较(lt)
   */
  private java.math.BigDecimal logisticsEstimatedFreightLt;
  /**
   * 预估运费 比较(lte)
   */
  private java.math.BigDecimal logisticsEstimatedFreightLte;
  /**
   * 预估运费 比较(contains)
   */
  private java.math.BigDecimal logisticsEstimatedFreightContains;
  /**
   * 预估运费 比较(notcontains)
   */
  private java.math.BigDecimal logisticsEstimatedFreightNotcontains;
  /**
   * 预估运费 比较(startswith)
   */
  private java.math.BigDecimal logisticsEstimatedFreightStartswith;
  /**
   * 预估运费 比较(endswith)
   */
  private java.math.BigDecimal logisticsEstimatedFreightEndswith;
  /**
   * 预估运费 比较(isnull)
   */
  private Boolean logisticsEstimatedFreightIsnull;
  /**
   * 预估运费 比较(isnotnull)
   */
  private Boolean logisticsEstimatedFreightIsnotnull;

  /**
   * 物流运费
   */
  private java.math.BigDecimal logisticsFreight;

  /**
   * 最小物流运费
   */
  private java.math.BigDecimal logisticsFreightMin;

  /**
   * 最大物流运费
   */
  private java.math.BigDecimal logisticsFreightMax;

  /**
   * 物流运费 比较(eq)
   */
  private java.math.BigDecimal logisticsFreightEq;
  /**
   * 物流运费 比较(neq)
   */
  private java.math.BigDecimal logisticsFreightNeq;
  /**
   * 物流运费 比较(gt)
   */
  private java.math.BigDecimal logisticsFreightGt;
  /**
   * 物流运费 比较(gte)
   */
  private java.math.BigDecimal logisticsFreightGte;
  /**
   * 物流运费 比较(lt)
   */
  private java.math.BigDecimal logisticsFreightLt;
  /**
   * 物流运费 比较(lte)
   */
  private java.math.BigDecimal logisticsFreightLte;
  /**
   * 物流运费 比较(contains)
   */
  private java.math.BigDecimal logisticsFreightContains;
  /**
   * 物流运费 比较(notcontains)
   */
  private java.math.BigDecimal logisticsFreightNotcontains;
  /**
   * 物流运费 比较(startswith)
   */
  private java.math.BigDecimal logisticsFreightStartswith;
  /**
   * 物流运费 比较(endswith)
   */
  private java.math.BigDecimal logisticsFreightEndswith;
  /**
   * 物流运费 比较(isnull)
   */
  private Boolean logisticsFreightIsnull;
  /**
   * 物流运费 比较(isnotnull)
   */
  private Boolean logisticsFreightIsnotnull;

  /**
   * 最早库存流水出库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date stockDeliveredAtStart;

  /**
   * 最晚库存流水出库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date stockDeliveredAtEnd;

  /**
   * 库存流水出库时间 比较(eq)
   */
  private Date stockDeliveredAtEq;
  /**
   * 库存流水出库时间 比较(neq)
   */
  private Date stockDeliveredAtNeq;
  /**
   * 库存流水出库时间 比较(gt)
   */
  private Date stockDeliveredAtGt;
  /**
   * 库存流水出库时间 比较(gte)
   */
  private Date stockDeliveredAtGte;
  /**
   * 库存流水出库时间 比较(lt)
   */
  private Date stockDeliveredAtLt;
  /**
   * 库存流水出库时间 比较(lte)
   */
  private Date stockDeliveredAtLte;
  /**
   * 库存流水出库时间 比较(contains)
   */
  private Date stockDeliveredAtContains;
  /**
   * 库存流水出库时间 比较(notcontains)
   */
  private Date stockDeliveredAtNotcontains;
  /**
   * 库存流水出库时间 比较(startswith)
   */
  private Date stockDeliveredAtStartswith;
  /**
   * 库存流水出库时间 比较(endswith)
   */
  private Date stockDeliveredAtEndswith;
  /**
   * 库存流水出库时间 比较(isnull)
   */
  private Boolean stockDeliveredAtIsnull;
  /**
   * 库存流水出库时间 比较(isnotnull)
   */
  private Boolean stockDeliveredAtIsnotnull;

  /**
   * 是否验货
   */
  private String isCheck;

  /**
   * 是否验货 比较(eq)
   */
  private String isCheckEq;
  /**
   * 是否验货 比较(neq)
   */
  private String isCheckNeq;
  /**
   * 是否验货 比较(gt)
   */
  private String isCheckGt;
  /**
   * 是否验货 比较(gte)
   */
  private String isCheckGte;
  /**
   * 是否验货 比较(lt)
   */
  private String isCheckLt;
  /**
   * 是否验货 比较(lte)
   */
  private String isCheckLte;
  /**
   * 是否验货 比较(contains)
   */
  private String isCheckContains;
  /**
   * 是否验货 比较(notcontains)
   */
  private String isCheckNotcontains;
  /**
   * 是否验货 比较(startswith)
   */
  private String isCheckStartswith;
  /**
   * 是否验货 比较(endswith)
   */
  private String isCheckEndswith;
  /**
   * 是否验货 比较(isnull)
   */
  private Boolean isCheckIsnull;
  /**
   * 是否验货 比较(isnotnull)
   */
  private Boolean isCheckIsnotnull;

  /**
   * 是否验货(精确搜索)
   */
  private List<String> isCheckInList;

  /**
   * 是否称重
   */
  private String isWeigh;

  /**
   * 是否称重 比较(eq)
   */
  private String isWeighEq;
  /**
   * 是否称重 比较(neq)
   */
  private String isWeighNeq;
  /**
   * 是否称重 比较(gt)
   */
  private String isWeighGt;
  /**
   * 是否称重 比较(gte)
   */
  private String isWeighGte;
  /**
   * 是否称重 比较(lt)
   */
  private String isWeighLt;
  /**
   * 是否称重 比较(lte)
   */
  private String isWeighLte;
  /**
   * 是否称重 比较(contains)
   */
  private String isWeighContains;
  /**
   * 是否称重 比较(notcontains)
   */
  private String isWeighNotcontains;
  /**
   * 是否称重 比较(startswith)
   */
  private String isWeighStartswith;
  /**
   * 是否称重 比较(endswith)
   */
  private String isWeighEndswith;
  /**
   * 是否称重 比较(isnull)
   */
  private Boolean isWeighIsnull;
  /**
   * 是否称重 比较(isnotnull)
   */
  private Boolean isWeighIsnotnull;

  /**
   * 是否称重(精确搜索)
   */
  private List<String> isWeighInList;

  /**
   * 面单是否打印
   */
  private String isSurfacePrint;

  /**
   * 面单是否打印 比较(eq)
   */
  private String isSurfacePrintEq;
  /**
   * 面单是否打印 比较(neq)
   */
  private String isSurfacePrintNeq;
  /**
   * 面单是否打印 比较(gt)
   */
  private String isSurfacePrintGt;
  /**
   * 面单是否打印 比较(gte)
   */
  private String isSurfacePrintGte;
  /**
   * 面单是否打印 比较(lt)
   */
  private String isSurfacePrintLt;
  /**
   * 面单是否打印 比较(lte)
   */
  private String isSurfacePrintLte;
  /**
   * 面单是否打印 比较(contains)
   */
  private String isSurfacePrintContains;
  /**
   * 面单是否打印 比较(notcontains)
   */
  private String isSurfacePrintNotcontains;
  /**
   * 面单是否打印 比较(startswith)
   */
  private String isSurfacePrintStartswith;
  /**
   * 面单是否打印 比较(endswith)
   */
  private String isSurfacePrintEndswith;
  /**
   * 面单是否打印 比较(isnull)
   */
  private Boolean isSurfacePrintIsnull;
  /**
   * 面单是否打印 比较(isnotnull)
   */
  private Boolean isSurfacePrintIsnotnull;

  /**
   * 面单是否打印(精确搜索)
   */
  private List<String> isSurfacePrintInList;

  /**
   * 订单是否打印
   */
  private String isorderPrint;

  /**
   * 订单是否打印 比较(eq)
   */
  private String isorderPrintEq;
  /**
   * 订单是否打印 比较(neq)
   */
  private String isorderPrintNeq;
  /**
   * 订单是否打印 比较(gt)
   */
  private String isorderPrintGt;
  /**
   * 订单是否打印 比较(gte)
   */
  private String isorderPrintGte;
  /**
   * 订单是否打印 比较(lt)
   */
  private String isorderPrintLt;
  /**
   * 订单是否打印 比较(lte)
   */
  private String isorderPrintLte;
  /**
   * 订单是否打印 比较(contains)
   */
  private String isorderPrintContains;
  /**
   * 订单是否打印 比较(notcontains)
   */
  private String isorderPrintNotcontains;
  /**
   * 订单是否打印 比较(startswith)
   */
  private String isorderPrintStartswith;
  /**
   * 订单是否打印 比较(endswith)
   */
  private String isorderPrintEndswith;
  /**
   * 订单是否打印 比较(isnull)
   */
  private Boolean isorderPrintIsnull;
  /**
   * 订单是否打印 比较(isnotnull)
   */
  private Boolean isorderPrintIsnotnull;

  /**
   * 订单是否打印(精确搜索)
   */
  private List<String> isorderPrintInList;

  /**
   * 包裹尺寸长
   */
  private java.math.BigDecimal pkgLength;

  /**
   * 最小包裹尺寸长
   */
  private java.math.BigDecimal pkgLengthMin;

  /**
   * 最大包裹尺寸长
   */
  private java.math.BigDecimal pkgLengthMax;

  /**
   * 包裹尺寸长 比较(eq)
   */
  private java.math.BigDecimal pkgLengthEq;
  /**
   * 包裹尺寸长 比较(neq)
   */
  private java.math.BigDecimal pkgLengthNeq;
  /**
   * 包裹尺寸长 比较(gt)
   */
  private java.math.BigDecimal pkgLengthGt;
  /**
   * 包裹尺寸长 比较(gte)
   */
  private java.math.BigDecimal pkgLengthGte;
  /**
   * 包裹尺寸长 比较(lt)
   */
  private java.math.BigDecimal pkgLengthLt;
  /**
   * 包裹尺寸长 比较(lte)
   */
  private java.math.BigDecimal pkgLengthLte;
  /**
   * 包裹尺寸长 比较(contains)
   */
  private java.math.BigDecimal pkgLengthContains;
  /**
   * 包裹尺寸长 比较(notcontains)
   */
  private java.math.BigDecimal pkgLengthNotcontains;
  /**
   * 包裹尺寸长 比较(startswith)
   */
  private java.math.BigDecimal pkgLengthStartswith;
  /**
   * 包裹尺寸长 比较(endswith)
   */
  private java.math.BigDecimal pkgLengthEndswith;
  /**
   * 包裹尺寸长 比较(isnull)
   */
  private Boolean pkgLengthIsnull;
  /**
   * 包裹尺寸长 比较(isnotnull)
   */
  private Boolean pkgLengthIsnotnull;

  /**
   * 包裹尺寸高
   */
  private java.math.BigDecimal pkgHeight;

  /**
   * 最小包裹尺寸高
   */
  private java.math.BigDecimal pkgHeightMin;

  /**
   * 最大包裹尺寸高
   */
  private java.math.BigDecimal pkgHeightMax;

  /**
   * 包裹尺寸高 比较(eq)
   */
  private java.math.BigDecimal pkgHeightEq;
  /**
   * 包裹尺寸高 比较(neq)
   */
  private java.math.BigDecimal pkgHeightNeq;
  /**
   * 包裹尺寸高 比较(gt)
   */
  private java.math.BigDecimal pkgHeightGt;
  /**
   * 包裹尺寸高 比较(gte)
   */
  private java.math.BigDecimal pkgHeightGte;
  /**
   * 包裹尺寸高 比较(lt)
   */
  private java.math.BigDecimal pkgHeightLt;
  /**
   * 包裹尺寸高 比较(lte)
   */
  private java.math.BigDecimal pkgHeightLte;
  /**
   * 包裹尺寸高 比较(contains)
   */
  private java.math.BigDecimal pkgHeightContains;
  /**
   * 包裹尺寸高 比较(notcontains)
   */
  private java.math.BigDecimal pkgHeightNotcontains;
  /**
   * 包裹尺寸高 比较(startswith)
   */
  private java.math.BigDecimal pkgHeightStartswith;
  /**
   * 包裹尺寸高 比较(endswith)
   */
  private java.math.BigDecimal pkgHeightEndswith;
  /**
   * 包裹尺寸高 比较(isnull)
   */
  private Boolean pkgHeightIsnull;
  /**
   * 包裹尺寸高 比较(isnotnull)
   */
  private Boolean pkgHeightIsnotnull;

  /**
   * 包裹实重
   */
  private java.math.BigDecimal pkgRealWeight;

  /**
   * 最小包裹实重
   */
  private java.math.BigDecimal pkgRealWeightMin;

  /**
   * 最大包裹实重
   */
  private java.math.BigDecimal pkgRealWeightMax;

  /**
   * 包裹实重 比较(eq)
   */
  private java.math.BigDecimal pkgRealWeightEq;
  /**
   * 包裹实重 比较(neq)
   */
  private java.math.BigDecimal pkgRealWeightNeq;
  /**
   * 包裹实重 比较(gt)
   */
  private java.math.BigDecimal pkgRealWeightGt;
  /**
   * 包裹实重 比较(gte)
   */
  private java.math.BigDecimal pkgRealWeightGte;
  /**
   * 包裹实重 比较(lt)
   */
  private java.math.BigDecimal pkgRealWeightLt;
  /**
   * 包裹实重 比较(lte)
   */
  private java.math.BigDecimal pkgRealWeightLte;
  /**
   * 包裹实重 比较(contains)
   */
  private java.math.BigDecimal pkgRealWeightContains;
  /**
   * 包裹实重 比较(notcontains)
   */
  private java.math.BigDecimal pkgRealWeightNotcontains;
  /**
   * 包裹实重 比较(startswith)
   */
  private java.math.BigDecimal pkgRealWeightStartswith;
  /**
   * 包裹实重 比较(endswith)
   */
  private java.math.BigDecimal pkgRealWeightEndswith;
  /**
   * 包裹实重 比较(isnull)
   */
  private Boolean pkgRealWeightIsnull;
  /**
   * 包裹实重 比较(isnotnull)
   */
  private Boolean pkgRealWeightIsnotnull;

  /**
   * 估算重量
   */
  private java.math.BigDecimal pkgWeight;

  /**
   * 最小估算重量
   */
  private java.math.BigDecimal pkgWeightMin;

  /**
   * 最大估算重量
   */
  private java.math.BigDecimal pkgWeightMax;

  /**
   * 估算重量 比较(eq)
   */
  private java.math.BigDecimal pkgWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private java.math.BigDecimal pkgWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private java.math.BigDecimal pkgWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private java.math.BigDecimal pkgWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private java.math.BigDecimal pkgWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private java.math.BigDecimal pkgWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private java.math.BigDecimal pkgWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private java.math.BigDecimal pkgWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private java.math.BigDecimal pkgWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private java.math.BigDecimal pkgWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean pkgWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean pkgWeightIsnotnull;

  /**
   * 订单类型
   */
  private String orderType;

  /**
   * 订单类型 比较(eq)
   */
  private String orderTypeEq;
  /**
   * 订单类型 比较(neq)
   */
  private String orderTypeNeq;
  /**
   * 订单类型 比较(gt)
   */
  private String orderTypeGt;
  /**
   * 订单类型 比较(gte)
   */
  private String orderTypeGte;
  /**
   * 订单类型 比较(lt)
   */
  private String orderTypeLt;
  /**
   * 订单类型 比较(lte)
   */
  private String orderTypeLte;
  /**
   * 订单类型 比较(contains)
   */
  private String orderTypeContains;
  /**
   * 订单类型 比较(notcontains)
   */
  private String orderTypeNotcontains;
  /**
   * 订单类型 比较(startswith)
   */
  private String orderTypeStartswith;
  /**
   * 订单类型 比较(endswith)
   */
  private String orderTypeEndswith;
  /**
   * 订单类型 比较(isnull)
   */
  private Boolean orderTypeIsnull;
  /**
   * 订单类型 比较(isnotnull)
   */
  private Boolean orderTypeIsnotnull;

  /**
   * 订单类型(精确搜索)
   */
  private List<String> orderTypeInList;

  /**
   * 收件人(模糊搜索)
   */
  private String recipient;

  /**
   * 收件人 比较(eq)
   */
  private String recipientEq;
  /**
   * 收件人 比较(neq)
   */
  private String recipientNeq;
  /**
   * 收件人 比较(gt)
   */
  private String recipientGt;
  /**
   * 收件人 比较(gte)
   */
  private String recipientGte;
  /**
   * 收件人 比较(lt)
   */
  private String recipientLt;
  /**
   * 收件人 比较(lte)
   */
  private String recipientLte;
  /**
   * 收件人 比较(contains)
   */
  private String recipientContains;
  /**
   * 收件人 比较(notcontains)
   */
  private String recipientNotcontains;
  /**
   * 收件人 比较(startswith)
   */
  private String recipientStartswith;
  /**
   * 收件人 比较(endswith)
   */
  private String recipientEndswith;
  /**
   * 收件人 比较(isnull)
   */
  private Boolean recipientIsnull;
  /**
   * 收件人 比较(isnotnull)
   */
  private Boolean recipientIsnotnull;

  /**
   * 收件人(精确搜索)
   */
  private List<String> recipientInList;

  /**
   * 电话(模糊搜索)
   */
  private String phone;

  /**
   * 电话 比较(eq)
   */
  private String phoneEq;
  /**
   * 电话 比较(neq)
   */
  private String phoneNeq;
  /**
   * 电话 比较(gt)
   */
  private String phoneGt;
  /**
   * 电话 比较(gte)
   */
  private String phoneGte;
  /**
   * 电话 比较(lt)
   */
  private String phoneLt;
  /**
   * 电话 比较(lte)
   */
  private String phoneLte;
  /**
   * 电话 比较(contains)
   */
  private String phoneContains;
  /**
   * 电话 比较(notcontains)
   */
  private String phoneNotcontains;
  /**
   * 电话 比较(startswith)
   */
  private String phoneStartswith;
  /**
   * 电话 比较(endswith)
   */
  private String phoneEndswith;
  /**
   * 电话 比较(isnull)
   */
  private Boolean phoneIsnull;
  /**
   * 电话 比较(isnotnull)
   */
  private Boolean phoneIsnotnull;

  /**
   * 电话(精确搜索)
   */
  private List<String> phoneInList;

  /**
   * 邮编(模糊搜索)
   */
  private String zipCode;

  /**
   * 邮编 比较(eq)
   */
  private String zipCodeEq;
  /**
   * 邮编 比较(neq)
   */
  private String zipCodeNeq;
  /**
   * 邮编 比较(gt)
   */
  private String zipCodeGt;
  /**
   * 邮编 比较(gte)
   */
  private String zipCodeGte;
  /**
   * 邮编 比较(lt)
   */
  private String zipCodeLt;
  /**
   * 邮编 比较(lte)
   */
  private String zipCodeLte;
  /**
   * 邮编 比较(contains)
   */
  private String zipCodeContains;
  /**
   * 邮编 比较(notcontains)
   */
  private String zipCodeNotcontains;
  /**
   * 邮编 比较(startswith)
   */
  private String zipCodeStartswith;
  /**
   * 邮编 比较(endswith)
   */
  private String zipCodeEndswith;
  /**
   * 邮编 比较(isnull)
   */
  private Boolean zipCodeIsnull;
  /**
   * 邮编 比较(isnotnull)
   */
  private Boolean zipCodeIsnotnull;

  /**
   * 邮编(精确搜索)
   */
  private List<String> zipCodeInList;

  /**
   * 收货地址(模糊搜索)
   */
  private String address;

  /**
   * 收货地址 比较(eq)
   */
  private String addressEq;
  /**
   * 收货地址 比较(neq)
   */
  private String addressNeq;
  /**
   * 收货地址 比较(gt)
   */
  private String addressGt;
  /**
   * 收货地址 比较(gte)
   */
  private String addressGte;
  /**
   * 收货地址 比较(lt)
   */
  private String addressLt;
  /**
   * 收货地址 比较(lte)
   */
  private String addressLte;
  /**
   * 收货地址 比较(contains)
   */
  private String addressContains;
  /**
   * 收货地址 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 收货地址 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 收货地址 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 收货地址 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 收货地址 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 收货地址(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 订单金额(模糊搜索)
   */
  private String orderOriginAmount;

  /**
   * 订单金额 比较(eq)
   */
  private String orderOriginAmountEq;
  /**
   * 订单金额 比较(neq)
   */
  private String orderOriginAmountNeq;
  /**
   * 订单金额 比较(gt)
   */
  private String orderOriginAmountGt;
  /**
   * 订单金额 比较(gte)
   */
  private String orderOriginAmountGte;
  /**
   * 订单金额 比较(lt)
   */
  private String orderOriginAmountLt;
  /**
   * 订单金额 比较(lte)
   */
  private String orderOriginAmountLte;
  /**
   * 订单金额 比较(contains)
   */
  private String orderOriginAmountContains;
  /**
   * 订单金额 比较(notcontains)
   */
  private String orderOriginAmountNotcontains;
  /**
   * 订单金额 比较(startswith)
   */
  private String orderOriginAmountStartswith;
  /**
   * 订单金额 比较(endswith)
   */
  private String orderOriginAmountEndswith;
  /**
   * 订单金额 比较(isnull)
   */
  private Boolean orderOriginAmountIsnull;
  /**
   * 订单金额 比较(isnotnull)
   */
  private Boolean orderOriginAmountIsnotnull;

  /**
   * 订单金额(精确搜索)
   */
  private List<String> orderOriginAmountInList;

  /**
   * 发货时限(模糊搜索)
   */
  private String deliverDeadline;

  /**
   * 发货时限 比较(eq)
   */
  private String deliverDeadlineEq;
  /**
   * 发货时限 比较(neq)
   */
  private String deliverDeadlineNeq;
  /**
   * 发货时限 比较(gt)
   */
  private String deliverDeadlineGt;
  /**
   * 发货时限 比较(gte)
   */
  private String deliverDeadlineGte;
  /**
   * 发货时限 比较(lt)
   */
  private String deliverDeadlineLt;
  /**
   * 发货时限 比较(lte)
   */
  private String deliverDeadlineLte;
  /**
   * 发货时限 比较(contains)
   */
  private String deliverDeadlineContains;
  /**
   * 发货时限 比较(notcontains)
   */
  private String deliverDeadlineNotcontains;
  /**
   * 发货时限 比较(startswith)
   */
  private String deliverDeadlineStartswith;
  /**
   * 发货时限 比较(endswith)
   */
  private String deliverDeadlineEndswith;
  /**
   * 发货时限 比较(isnull)
   */
  private Boolean deliverDeadlineIsnull;
  /**
   * 发货时限 比较(isnotnull)
   */
  private Boolean deliverDeadlineIsnotnull;

  /**
   * 发货时限(精确搜索)
   */
  private List<String> deliverDeadlineInList;

  /**
   * 客服备注(模糊搜索)
   */
  private String orderCustomerServiceNotes;

  /**
   * 客服备注 比较(eq)
   */
  private String orderCustomerServiceNotesEq;
  /**
   * 客服备注 比较(neq)
   */
  private String orderCustomerServiceNotesNeq;
  /**
   * 客服备注 比较(gt)
   */
  private String orderCustomerServiceNotesGt;
  /**
   * 客服备注 比较(gte)
   */
  private String orderCustomerServiceNotesGte;
  /**
   * 客服备注 比较(lt)
   */
  private String orderCustomerServiceNotesLt;
  /**
   * 客服备注 比较(lte)
   */
  private String orderCustomerServiceNotesLte;
  /**
   * 客服备注 比较(contains)
   */
  private String orderCustomerServiceNotesContains;
  /**
   * 客服备注 比较(notcontains)
   */
  private String orderCustomerServiceNotesNotcontains;
  /**
   * 客服备注 比较(startswith)
   */
  private String orderCustomerServiceNotesStartswith;
  /**
   * 客服备注 比较(endswith)
   */
  private String orderCustomerServiceNotesEndswith;
  /**
   * 客服备注 比较(isnull)
   */
  private Boolean orderCustomerServiceNotesIsnull;
  /**
   * 客服备注 比较(isnotnull)
   */
  private Boolean orderCustomerServiceNotesIsnotnull;

  /**
   * 客服备注(精确搜索)
   */
  private List<String> orderCustomerServiceNotesInList;

  /**
   * 买家留言(模糊搜索)
   */
  private String orderBuyerNotes;

  /**
   * 买家留言 比较(eq)
   */
  private String orderBuyerNotesEq;
  /**
   * 买家留言 比较(neq)
   */
  private String orderBuyerNotesNeq;
  /**
   * 买家留言 比较(gt)
   */
  private String orderBuyerNotesGt;
  /**
   * 买家留言 比较(gte)
   */
  private String orderBuyerNotesGte;
  /**
   * 买家留言 比较(lt)
   */
  private String orderBuyerNotesLt;
  /**
   * 买家留言 比较(lte)
   */
  private String orderBuyerNotesLte;
  /**
   * 买家留言 比较(contains)
   */
  private String orderBuyerNotesContains;
  /**
   * 买家留言 比较(notcontains)
   */
  private String orderBuyerNotesNotcontains;
  /**
   * 买家留言 比较(startswith)
   */
  private String orderBuyerNotesStartswith;
  /**
   * 买家留言 比较(endswith)
   */
  private String orderBuyerNotesEndswith;
  /**
   * 买家留言 比较(isnull)
   */
  private Boolean orderBuyerNotesIsnull;
  /**
   * 买家留言 比较(isnotnull)
   */
  private Boolean orderBuyerNotesIsnotnull;

  /**
   * 买家留言(精确搜索)
   */
  private List<String> orderBuyerNotesInList;

  /**
   * 包裹体积
   */
  private java.math.BigDecimal pkgVolume;

  /**
   * 最小包裹体积
   */
  private java.math.BigDecimal pkgVolumeMin;

  /**
   * 最大包裹体积
   */
  private java.math.BigDecimal pkgVolumeMax;

  /**
   * 包裹体积 比较(eq)
   */
  private java.math.BigDecimal pkgVolumeEq;
  /**
   * 包裹体积 比较(neq)
   */
  private java.math.BigDecimal pkgVolumeNeq;
  /**
   * 包裹体积 比较(gt)
   */
  private java.math.BigDecimal pkgVolumeGt;
  /**
   * 包裹体积 比较(gte)
   */
  private java.math.BigDecimal pkgVolumeGte;
  /**
   * 包裹体积 比较(lt)
   */
  private java.math.BigDecimal pkgVolumeLt;
  /**
   * 包裹体积 比较(lte)
   */
  private java.math.BigDecimal pkgVolumeLte;
  /**
   * 包裹体积 比较(contains)
   */
  private java.math.BigDecimal pkgVolumeContains;
  /**
   * 包裹体积 比较(notcontains)
   */
  private java.math.BigDecimal pkgVolumeNotcontains;
  /**
   * 包裹体积 比较(startswith)
   */
  private java.math.BigDecimal pkgVolumeStartswith;
  /**
   * 包裹体积 比较(endswith)
   */
  private java.math.BigDecimal pkgVolumeEndswith;
  /**
   * 包裹体积 比较(isnull)
   */
  private Boolean pkgVolumeIsnull;
  /**
   * 包裹体积 比较(isnotnull)
   */
  private Boolean pkgVolumeIsnotnull;

  /**
   * 加工单号(模糊搜索)
   */
  private String processSn;

  /**
   * 加工单号 比较(eq)
   */
  private String processSnEq;
  /**
   * 加工单号 比较(neq)
   */
  private String processSnNeq;
  /**
   * 加工单号 比较(gt)
   */
  private String processSnGt;
  /**
   * 加工单号 比较(gte)
   */
  private String processSnGte;
  /**
   * 加工单号 比较(lt)
   */
  private String processSnLt;
  /**
   * 加工单号 比较(lte)
   */
  private String processSnLte;
  /**
   * 加工单号 比较(contains)
   */
  private String processSnContains;
  /**
   * 加工单号 比较(notcontains)
   */
  private String processSnNotcontains;
  /**
   * 加工单号 比较(startswith)
   */
  private String processSnStartswith;
  /**
   * 加工单号 比较(endswith)
   */
  private String processSnEndswith;
  /**
   * 加工单号 比较(isnull)
   */
  private Boolean processSnIsnull;
  /**
   * 加工单号 比较(isnotnull)
   */
  private Boolean processSnIsnotnull;

  /**
   * 加工单号(精确搜索)
   */
  private List<String> processSnInList;

  /**
   * 订单来源(模糊搜索)
   */
  private String orderFrom;

  /**
   * 订单来源 比较(eq)
   */
  private String orderFromEq;
  /**
   * 订单来源 比较(neq)
   */
  private String orderFromNeq;
  /**
   * 订单来源 比较(gt)
   */
  private String orderFromGt;
  /**
   * 订单来源 比较(gte)
   */
  private String orderFromGte;
  /**
   * 订单来源 比较(lt)
   */
  private String orderFromLt;
  /**
   * 订单来源 比较(lte)
   */
  private String orderFromLte;
  /**
   * 订单来源 比较(contains)
   */
  private String orderFromContains;
  /**
   * 订单来源 比较(notcontains)
   */
  private String orderFromNotcontains;
  /**
   * 订单来源 比较(startswith)
   */
  private String orderFromStartswith;
  /**
   * 订单来源 比较(endswith)
   */
  private String orderFromEndswith;
  /**
   * 订单来源 比较(isnull)
   */
  private Boolean orderFromIsnull;
  /**
   * 订单来源 比较(isnotnull)
   */
  private Boolean orderFromIsnotnull;

  /**
   * 订单来源(精确搜索)
   */
  private List<String> orderFromInList;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 批次号(模糊搜索)
   */
  private String batchNo;

  /**
   * 批次号 比较(eq)
   */
  private String batchNoEq;
  /**
   * 批次号 比较(neq)
   */
  private String batchNoNeq;
  /**
   * 批次号 比较(gt)
   */
  private String batchNoGt;
  /**
   * 批次号 比较(gte)
   */
  private String batchNoGte;
  /**
   * 批次号 比较(lt)
   */
  private String batchNoLt;
  /**
   * 批次号 比较(lte)
   */
  private String batchNoLte;
  /**
   * 批次号 比较(contains)
   */
  private String batchNoContains;
  /**
   * 批次号 比较(notcontains)
   */
  private String batchNoNotcontains;
  /**
   * 批次号 比较(startswith)
   */
  private String batchNoStartswith;
  /**
   * 批次号 比较(endswith)
   */
  private String batchNoEndswith;
  /**
   * 批次号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批次号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 批次号(精确搜索)
   */
  private List<String> batchNoInList;

  /**
   * 拣货人(模糊搜索)
   */
  private String picker;

  /**
   * 拣货人 比较(eq)
   */
  private String pickerEq;
  /**
   * 拣货人 比较(neq)
   */
  private String pickerNeq;
  /**
   * 拣货人 比较(gt)
   */
  private String pickerGt;
  /**
   * 拣货人 比较(gte)
   */
  private String pickerGte;
  /**
   * 拣货人 比较(lt)
   */
  private String pickerLt;
  /**
   * 拣货人 比较(lte)
   */
  private String pickerLte;
  /**
   * 拣货人 比较(contains)
   */
  private String pickerContains;
  /**
   * 拣货人 比较(notcontains)
   */
  private String pickerNotcontains;
  /**
   * 拣货人 比较(startswith)
   */
  private String pickerStartswith;
  /**
   * 拣货人 比较(endswith)
   */
  private String pickerEndswith;
  /**
   * 拣货人 比较(isnull)
   */
  private Boolean pickerIsnull;
  /**
   * 拣货人 比较(isnotnull)
   */
  private Boolean pickerIsnotnull;

  /**
   * 拣货人(精确搜索)
   */
  private List<String> pickerInList;

  /**
   * 物流下单状态
   */
  private String logisticsStatus;

  /**
   * 物流下单状态 比较(eq)
   */
  private String logisticsStatusEq;
  /**
   * 物流下单状态 比较(neq)
   */
  private String logisticsStatusNeq;
  /**
   * 物流下单状态 比较(gt)
   */
  private String logisticsStatusGt;
  /**
   * 物流下单状态 比较(gte)
   */
  private String logisticsStatusGte;
  /**
   * 物流下单状态 比较(lt)
   */
  private String logisticsStatusLt;
  /**
   * 物流下单状态 比较(lte)
   */
  private String logisticsStatusLte;
  /**
   * 物流下单状态 比较(contains)
   */
  private String logisticsStatusContains;
  /**
   * 物流下单状态 比较(notcontains)
   */
  private String logisticsStatusNotcontains;
  /**
   * 物流下单状态 比较(startswith)
   */
  private String logisticsStatusStartswith;
  /**
   * 物流下单状态 比较(endswith)
   */
  private String logisticsStatusEndswith;
  /**
   * 物流下单状态 比较(isnull)
   */
  private Boolean logisticsStatusIsnull;
  /**
   * 物流下单状态 比较(isnotnull)
   */
  private Boolean logisticsStatusIsnotnull;

  /**
   * 物流下单状态(精确搜索)
   */
  private List<String> logisticsStatusInList;

  /**
   * 物流下单消息(模糊搜索)
   */
  private String logisticsMessage;

  /**
   * 物流下单消息 比较(eq)
   */
  private String logisticsMessageEq;
  /**
   * 物流下单消息 比较(neq)
   */
  private String logisticsMessageNeq;
  /**
   * 物流下单消息 比较(gt)
   */
  private String logisticsMessageGt;
  /**
   * 物流下单消息 比较(gte)
   */
  private String logisticsMessageGte;
  /**
   * 物流下单消息 比较(lt)
   */
  private String logisticsMessageLt;
  /**
   * 物流下单消息 比较(lte)
   */
  private String logisticsMessageLte;
  /**
   * 物流下单消息 比较(contains)
   */
  private String logisticsMessageContains;
  /**
   * 物流下单消息 比较(notcontains)
   */
  private String logisticsMessageNotcontains;
  /**
   * 物流下单消息 比较(startswith)
   */
  private String logisticsMessageStartswith;
  /**
   * 物流下单消息 比较(endswith)
   */
  private String logisticsMessageEndswith;
  /**
   * 物流下单消息 比较(isnull)
   */
  private Boolean logisticsMessageIsnull;
  /**
   * 物流下单消息 比较(isnotnull)
   */
  private Boolean logisticsMessageIsnotnull;

  /**
   * 物流下单消息(精确搜索)
   */
  private List<String> logisticsMessageInList;

  /**
   * 订单币种(模糊搜索)
   */
  private String orderCurrencyCode;

  /**
   * 订单币种 比较(eq)
   */
  private String orderCurrencyCodeEq;
  /**
   * 订单币种 比较(neq)
   */
  private String orderCurrencyCodeNeq;
  /**
   * 订单币种 比较(gt)
   */
  private String orderCurrencyCodeGt;
  /**
   * 订单币种 比较(gte)
   */
  private String orderCurrencyCodeGte;
  /**
   * 订单币种 比较(lt)
   */
  private String orderCurrencyCodeLt;
  /**
   * 订单币种 比较(lte)
   */
  private String orderCurrencyCodeLte;
  /**
   * 订单币种 比较(contains)
   */
  private String orderCurrencyCodeContains;
  /**
   * 订单币种 比较(notcontains)
   */
  private String orderCurrencyCodeNotcontains;
  /**
   * 订单币种 比较(startswith)
   */
  private String orderCurrencyCodeStartswith;
  /**
   * 订单币种 比较(endswith)
   */
  private String orderCurrencyCodeEndswith;
  /**
   * 订单币种 比较(isnull)
   */
  private Boolean orderCurrencyCodeIsnull;
  /**
   * 订单币种 比较(isnotnull)
   */
  private Boolean orderCurrencyCodeIsnotnull;

  /**
   * 订单币种(精确搜索)
   */
  private List<String> orderCurrencyCodeInList;

  /**
   * 店铺名称(模糊搜索)
   */
  private String sellerName;

  /**
   * 店铺名称 比较(eq)
   */
  private String sellerNameEq;
  /**
   * 店铺名称 比较(neq)
   */
  private String sellerNameNeq;
  /**
   * 店铺名称 比较(gt)
   */
  private String sellerNameGt;
  /**
   * 店铺名称 比较(gte)
   */
  private String sellerNameGte;
  /**
   * 店铺名称 比较(lt)
   */
  private String sellerNameLt;
  /**
   * 店铺名称 比较(lte)
   */
  private String sellerNameLte;
  /**
   * 店铺名称 比较(contains)
   */
  private String sellerNameContains;
  /**
   * 店铺名称 比较(notcontains)
   */
  private String sellerNameNotcontains;
  /**
   * 店铺名称 比较(startswith)
   */
  private String sellerNameStartswith;
  /**
   * 店铺名称 比较(endswith)
   */
  private String sellerNameEndswith;
  /**
   * 店铺名称 比较(isnull)
   */
  private Boolean sellerNameIsnull;
  /**
   * 店铺名称 比较(isnotnull)
   */
  private Boolean sellerNameIsnotnull;

  /**
   * 店铺名称(精确搜索)
   */
  private List<String> sellerNameInList;

  /**
   * 是否有 面单文件
   */
  private Boolean surfaceFile;

  /**
   * 物流服务商名称(模糊搜索)
   */
  private String logisticsProviderName;

  /**
   * 物流服务商名称 比较(eq)
   */
  private String logisticsProviderNameEq;
  /**
   * 物流服务商名称 比较(neq)
   */
  private String logisticsProviderNameNeq;
  /**
   * 物流服务商名称 比较(gt)
   */
  private String logisticsProviderNameGt;
  /**
   * 物流服务商名称 比较(gte)
   */
  private String logisticsProviderNameGte;
  /**
   * 物流服务商名称 比较(lt)
   */
  private String logisticsProviderNameLt;
  /**
   * 物流服务商名称 比较(lte)
   */
  private String logisticsProviderNameLte;
  /**
   * 物流服务商名称 比较(contains)
   */
  private String logisticsProviderNameContains;
  /**
   * 物流服务商名称 比较(notcontains)
   */
  private String logisticsProviderNameNotcontains;
  /**
   * 物流服务商名称 比较(startswith)
   */
  private String logisticsProviderNameStartswith;
  /**
   * 物流服务商名称 比较(endswith)
   */
  private String logisticsProviderNameEndswith;
  /**
   * 物流服务商名称 比较(isnull)
   */
  private Boolean logisticsProviderNameIsnull;
  /**
   * 物流服务商名称 比较(isnotnull)
   */
  private Boolean logisticsProviderNameIsnotnull;

  /**
   * 物流服务商名称(精确搜索)
   */
  private List<String> logisticsProviderNameInList;

  /**
   * 物流方式名称(模糊搜索)
   */
  private String logisticsTypeName;

  /**
   * 物流方式名称 比较(eq)
   */
  private String logisticsTypeNameEq;
  /**
   * 物流方式名称 比较(neq)
   */
  private String logisticsTypeNameNeq;
  /**
   * 物流方式名称 比较(gt)
   */
  private String logisticsTypeNameGt;
  /**
   * 物流方式名称 比较(gte)
   */
  private String logisticsTypeNameGte;
  /**
   * 物流方式名称 比较(lt)
   */
  private String logisticsTypeNameLt;
  /**
   * 物流方式名称 比较(lte)
   */
  private String logisticsTypeNameLte;
  /**
   * 物流方式名称 比较(contains)
   */
  private String logisticsTypeNameContains;
  /**
   * 物流方式名称 比较(notcontains)
   */
  private String logisticsTypeNameNotcontains;
  /**
   * 物流方式名称 比较(startswith)
   */
  private String logisticsTypeNameStartswith;
  /**
   * 物流方式名称 比较(endswith)
   */
  private String logisticsTypeNameEndswith;
  /**
   * 物流方式名称 比较(isnull)
   */
  private Boolean logisticsTypeNameIsnull;
  /**
   * 物流方式名称 比较(isnotnull)
   */
  private Boolean logisticsTypeNameIsnotnull;

  /**
   * 物流方式名称(精确搜索)
   */
  private List<String> logisticsTypeNameInList;

  /**
   * 包裹尺寸宽
   */
  private java.math.BigDecimal pkgWidth;

  /**
   * 最小包裹尺寸宽
   */
  private java.math.BigDecimal pkgWidthMin;

  /**
   * 最大包裹尺寸宽
   */
  private java.math.BigDecimal pkgWidthMax;

  /**
   * 包裹尺寸宽 比较(eq)
   */
  private java.math.BigDecimal pkgWidthEq;
  /**
   * 包裹尺寸宽 比较(neq)
   */
  private java.math.BigDecimal pkgWidthNeq;
  /**
   * 包裹尺寸宽 比较(gt)
   */
  private java.math.BigDecimal pkgWidthGt;
  /**
   * 包裹尺寸宽 比较(gte)
   */
  private java.math.BigDecimal pkgWidthGte;
  /**
   * 包裹尺寸宽 比较(lt)
   */
  private java.math.BigDecimal pkgWidthLt;
  /**
   * 包裹尺寸宽 比较(lte)
   */
  private java.math.BigDecimal pkgWidthLte;
  /**
   * 包裹尺寸宽 比较(contains)
   */
  private java.math.BigDecimal pkgWidthContains;
  /**
   * 包裹尺寸宽 比较(notcontains)
   */
  private java.math.BigDecimal pkgWidthNotcontains;
  /**
   * 包裹尺寸宽 比较(startswith)
   */
  private java.math.BigDecimal pkgWidthStartswith;
  /**
   * 包裹尺寸宽 比较(endswith)
   */
  private java.math.BigDecimal pkgWidthEndswith;
  /**
   * 包裹尺寸宽 比较(isnull)
   */
  private Boolean pkgWidthIsnull;
  /**
   * 包裹尺寸宽 比较(isnotnull)
   */
  private Boolean pkgWidthIsnotnull;

  /**
   * 包裹计费重
   */
  private java.math.BigDecimal pkgFeeWeight;

  /**
   * 最小包裹计费重
   */
  private java.math.BigDecimal pkgFeeWeightMin;

  /**
   * 最大包裹计费重
   */
  private java.math.BigDecimal pkgFeeWeightMax;

  /**
   * 包裹计费重 比较(eq)
   */
  private java.math.BigDecimal pkgFeeWeightEq;
  /**
   * 包裹计费重 比较(neq)
   */
  private java.math.BigDecimal pkgFeeWeightNeq;
  /**
   * 包裹计费重 比较(gt)
   */
  private java.math.BigDecimal pkgFeeWeightGt;
  /**
   * 包裹计费重 比较(gte)
   */
  private java.math.BigDecimal pkgFeeWeightGte;
  /**
   * 包裹计费重 比较(lt)
   */
  private java.math.BigDecimal pkgFeeWeightLt;
  /**
   * 包裹计费重 比较(lte)
   */
  private java.math.BigDecimal pkgFeeWeightLte;
  /**
   * 包裹计费重 比较(contains)
   */
  private java.math.BigDecimal pkgFeeWeightContains;
  /**
   * 包裹计费重 比较(notcontains)
   */
  private java.math.BigDecimal pkgFeeWeightNotcontains;
  /**
   * 包裹计费重 比较(startswith)
   */
  private java.math.BigDecimal pkgFeeWeightStartswith;
  /**
   * 包裹计费重 比较(endswith)
   */
  private java.math.BigDecimal pkgFeeWeightEndswith;
  /**
   * 包裹计费重 比较(isnull)
   */
  private Boolean pkgFeeWeightIsnull;
  /**
   * 包裹计费重 比较(isnotnull)
   */
  private Boolean pkgFeeWeightIsnotnull;

  /**
   * 预估重量单位(模糊搜索)
   */
  private String pkgWeightUnit;

  /**
   * 预估重量单位 比较(eq)
   */
  private String pkgWeightUnitEq;
  /**
   * 预估重量单位 比较(neq)
   */
  private String pkgWeightUnitNeq;
  /**
   * 预估重量单位 比较(gt)
   */
  private String pkgWeightUnitGt;
  /**
   * 预估重量单位 比较(gte)
   */
  private String pkgWeightUnitGte;
  /**
   * 预估重量单位 比较(lt)
   */
  private String pkgWeightUnitLt;
  /**
   * 预估重量单位 比较(lte)
   */
  private String pkgWeightUnitLte;
  /**
   * 预估重量单位 比较(contains)
   */
  private String pkgWeightUnitContains;
  /**
   * 预估重量单位 比较(notcontains)
   */
  private String pkgWeightUnitNotcontains;
  /**
   * 预估重量单位 比较(startswith)
   */
  private String pkgWeightUnitStartswith;
  /**
   * 预估重量单位 比较(endswith)
   */
  private String pkgWeightUnitEndswith;
  /**
   * 预估重量单位 比较(isnull)
   */
  private Boolean pkgWeightUnitIsnull;
  /**
   * 预估重量单位 比较(isnotnull)
   */
  private Boolean pkgWeightUnitIsnotnull;

  /**
   * 预估重量单位(精确搜索)
   */
  private List<String> pkgWeightUnitInList;

  /**
   * 包裹实重单位(模糊搜索)
   */
  private String pkgRealWeightUnit;

  /**
   * 包裹实重单位 比较(eq)
   */
  private String pkgRealWeightUnitEq;
  /**
   * 包裹实重单位 比较(neq)
   */
  private String pkgRealWeightUnitNeq;
  /**
   * 包裹实重单位 比较(gt)
   */
  private String pkgRealWeightUnitGt;
  /**
   * 包裹实重单位 比较(gte)
   */
  private String pkgRealWeightUnitGte;
  /**
   * 包裹实重单位 比较(lt)
   */
  private String pkgRealWeightUnitLt;
  /**
   * 包裹实重单位 比较(lte)
   */
  private String pkgRealWeightUnitLte;
  /**
   * 包裹实重单位 比较(contains)
   */
  private String pkgRealWeightUnitContains;
  /**
   * 包裹实重单位 比较(notcontains)
   */
  private String pkgRealWeightUnitNotcontains;
  /**
   * 包裹实重单位 比较(startswith)
   */
  private String pkgRealWeightUnitStartswith;
  /**
   * 包裹实重单位 比较(endswith)
   */
  private String pkgRealWeightUnitEndswith;
  /**
   * 包裹实重单位 比较(isnull)
   */
  private Boolean pkgRealWeightUnitIsnull;
  /**
   * 包裹实重单位 比较(isnotnull)
   */
  private Boolean pkgRealWeightUnitIsnotnull;

  /**
   * 包裹实重单位(精确搜索)
   */
  private List<String> pkgRealWeightUnitInList;

  /**
   * 包裹计费重单位(模糊搜索)
   */
  private String pkgFeeWeightUnit;

  /**
   * 包裹计费重单位 比较(eq)
   */
  private String pkgFeeWeightUnitEq;
  /**
   * 包裹计费重单位 比较(neq)
   */
  private String pkgFeeWeightUnitNeq;
  /**
   * 包裹计费重单位 比较(gt)
   */
  private String pkgFeeWeightUnitGt;
  /**
   * 包裹计费重单位 比较(gte)
   */
  private String pkgFeeWeightUnitGte;
  /**
   * 包裹计费重单位 比较(lt)
   */
  private String pkgFeeWeightUnitLt;
  /**
   * 包裹计费重单位 比较(lte)
   */
  private String pkgFeeWeightUnitLte;
  /**
   * 包裹计费重单位 比较(contains)
   */
  private String pkgFeeWeightUnitContains;
  /**
   * 包裹计费重单位 比较(notcontains)
   */
  private String pkgFeeWeightUnitNotcontains;
  /**
   * 包裹计费重单位 比较(startswith)
   */
  private String pkgFeeWeightUnitStartswith;
  /**
   * 包裹计费重单位 比较(endswith)
   */
  private String pkgFeeWeightUnitEndswith;
  /**
   * 包裹计费重单位 比较(isnull)
   */
  private Boolean pkgFeeWeightUnitIsnull;
  /**
   * 包裹计费重单位 比较(isnotnull)
   */
  private Boolean pkgFeeWeightUnitIsnotnull;

  /**
   * 包裹计费重单位(精确搜索)
   */
  private List<String> pkgFeeWeightUnitInList;

  /**
   * 包裹尺寸单位(模糊搜索)
   */
  private String pkgSizeUnit;

  /**
   * 包裹尺寸单位 比较(eq)
   */
  private String pkgSizeUnitEq;
  /**
   * 包裹尺寸单位 比较(neq)
   */
  private String pkgSizeUnitNeq;
  /**
   * 包裹尺寸单位 比较(gt)
   */
  private String pkgSizeUnitGt;
  /**
   * 包裹尺寸单位 比较(gte)
   */
  private String pkgSizeUnitGte;
  /**
   * 包裹尺寸单位 比较(lt)
   */
  private String pkgSizeUnitLt;
  /**
   * 包裹尺寸单位 比较(lte)
   */
  private String pkgSizeUnitLte;
  /**
   * 包裹尺寸单位 比较(contains)
   */
  private String pkgSizeUnitContains;
  /**
   * 包裹尺寸单位 比较(notcontains)
   */
  private String pkgSizeUnitNotcontains;
  /**
   * 包裹尺寸单位 比较(startswith)
   */
  private String pkgSizeUnitStartswith;
  /**
   * 包裹尺寸单位 比较(endswith)
   */
  private String pkgSizeUnitEndswith;
  /**
   * 包裹尺寸单位 比较(isnull)
   */
  private Boolean pkgSizeUnitIsnull;
  /**
   * 包裹尺寸单位 比较(isnotnull)
   */
  private Boolean pkgSizeUnitIsnotnull;

  /**
   * 包裹尺寸单位(精确搜索)
   */
  private List<String> pkgSizeUnitInList;

  /**
   * 预估运费币种(模糊搜索)
   */
  private String logisticsEstimatedFreightCurrencyCode;

  /**
   * 预估运费币种 比较(eq)
   */
  private String logisticsEstimatedFreightCurrencyCodeEq;
  /**
   * 预估运费币种 比较(neq)
   */
  private String logisticsEstimatedFreightCurrencyCodeNeq;
  /**
   * 预估运费币种 比较(gt)
   */
  private String logisticsEstimatedFreightCurrencyCodeGt;
  /**
   * 预估运费币种 比较(gte)
   */
  private String logisticsEstimatedFreightCurrencyCodeGte;
  /**
   * 预估运费币种 比较(lt)
   */
  private String logisticsEstimatedFreightCurrencyCodeLt;
  /**
   * 预估运费币种 比较(lte)
   */
  private String logisticsEstimatedFreightCurrencyCodeLte;
  /**
   * 预估运费币种 比较(contains)
   */
  private String logisticsEstimatedFreightCurrencyCodeContains;
  /**
   * 预估运费币种 比较(notcontains)
   */
  private String logisticsEstimatedFreightCurrencyCodeNotcontains;
  /**
   * 预估运费币种 比较(startswith)
   */
  private String logisticsEstimatedFreightCurrencyCodeStartswith;
  /**
   * 预估运费币种 比较(endswith)
   */
  private String logisticsEstimatedFreightCurrencyCodeEndswith;
  /**
   * 预估运费币种 比较(isnull)
   */
  private Boolean logisticsEstimatedFreightCurrencyCodeIsnull;
  /**
   * 预估运费币种 比较(isnotnull)
   */
  private Boolean logisticsEstimatedFreightCurrencyCodeIsnotnull;

  /**
   * 预估运费币种(精确搜索)
   */
  private List<String> logisticsEstimatedFreightCurrencyCodeInList;

  /**
   * 物流运费币种(模糊搜索)
   */
  private String logisticsFreightCurrencyCode;

  /**
   * 物流运费币种 比较(eq)
   */
  private String logisticsFreightCurrencyCodeEq;
  /**
   * 物流运费币种 比较(neq)
   */
  private String logisticsFreightCurrencyCodeNeq;
  /**
   * 物流运费币种 比较(gt)
   */
  private String logisticsFreightCurrencyCodeGt;
  /**
   * 物流运费币种 比较(gte)
   */
  private String logisticsFreightCurrencyCodeGte;
  /**
   * 物流运费币种 比较(lt)
   */
  private String logisticsFreightCurrencyCodeLt;
  /**
   * 物流运费币种 比较(lte)
   */
  private String logisticsFreightCurrencyCodeLte;
  /**
   * 物流运费币种 比较(contains)
   */
  private String logisticsFreightCurrencyCodeContains;
  /**
   * 物流运费币种 比较(notcontains)
   */
  private String logisticsFreightCurrencyCodeNotcontains;
  /**
   * 物流运费币种 比较(startswith)
   */
  private String logisticsFreightCurrencyCodeStartswith;
  /**
   * 物流运费币种 比较(endswith)
   */
  private String logisticsFreightCurrencyCodeEndswith;
  /**
   * 物流运费币种 比较(isnull)
   */
  private Boolean logisticsFreightCurrencyCodeIsnull;
  /**
   * 物流运费币种 比较(isnotnull)
   */
  private Boolean logisticsFreightCurrencyCodeIsnotnull;

  /**
   * 物流运费币种(精确搜索)
   */
  private List<String> logisticsFreightCurrencyCodeInList;

  /**
   * 发件人税号(模糊搜索)
   */
  private String senderTaxNo;

  /**
   * 发件人税号 比较(eq)
   */
  private String senderTaxNoEq;
  /**
   * 发件人税号 比较(neq)
   */
  private String senderTaxNoNeq;
  /**
   * 发件人税号 比较(gt)
   */
  private String senderTaxNoGt;
  /**
   * 发件人税号 比较(gte)
   */
  private String senderTaxNoGte;
  /**
   * 发件人税号 比较(lt)
   */
  private String senderTaxNoLt;
  /**
   * 发件人税号 比较(lte)
   */
  private String senderTaxNoLte;
  /**
   * 发件人税号 比较(contains)
   */
  private String senderTaxNoContains;
  /**
   * 发件人税号 比较(notcontains)
   */
  private String senderTaxNoNotcontains;
  /**
   * 发件人税号 比较(startswith)
   */
  private String senderTaxNoStartswith;
  /**
   * 发件人税号 比较(endswith)
   */
  private String senderTaxNoEndswith;
  /**
   * 发件人税号 比较(isnull)
   */
  private Boolean senderTaxNoIsnull;
  /**
   * 发件人税号 比较(isnotnull)
   */
  private Boolean senderTaxNoIsnotnull;

  /**
   * 发件人税号(精确搜索)
   */
  private List<String> senderTaxNoInList;

  /**
   * 城市(模糊搜索)
   */
  private String city;

  /**
   * 城市 比较(eq)
   */
  private String cityEq;
  /**
   * 城市 比较(neq)
   */
  private String cityNeq;
  /**
   * 城市 比较(gt)
   */
  private String cityGt;
  /**
   * 城市 比较(gte)
   */
  private String cityGte;
  /**
   * 城市 比较(lt)
   */
  private String cityLt;
  /**
   * 城市 比较(lte)
   */
  private String cityLte;
  /**
   * 城市 比较(contains)
   */
  private String cityContains;
  /**
   * 城市 比较(notcontains)
   */
  private String cityNotcontains;
  /**
   * 城市 比较(startswith)
   */
  private String cityStartswith;
  /**
   * 城市 比较(endswith)
   */
  private String cityEndswith;
  /**
   * 城市 比较(isnull)
   */
  private Boolean cityIsnull;
  /**
   * 城市 比较(isnotnull)
   */
  private Boolean cityIsnotnull;

  /**
   * 城市(精确搜索)
   */
  private List<String> cityInList;

  /**
   * 省/州(模糊搜索)
   */
  private String provinceState;

  /**
   * 省/州 比较(eq)
   */
  private String provinceStateEq;
  /**
   * 省/州 比较(neq)
   */
  private String provinceStateNeq;
  /**
   * 省/州 比较(gt)
   */
  private String provinceStateGt;
  /**
   * 省/州 比较(gte)
   */
  private String provinceStateGte;
  /**
   * 省/州 比较(lt)
   */
  private String provinceStateLt;
  /**
   * 省/州 比较(lte)
   */
  private String provinceStateLte;
  /**
   * 省/州 比较(contains)
   */
  private String provinceStateContains;
  /**
   * 省/州 比较(notcontains)
   */
  private String provinceStateNotcontains;
  /**
   * 省/州 比较(startswith)
   */
  private String provinceStateStartswith;
  /**
   * 省/州 比较(endswith)
   */
  private String provinceStateEndswith;
  /**
   * 省/州 比较(isnull)
   */
  private Boolean provinceStateIsnull;
  /**
   * 省/州 比较(isnotnull)
   */
  private Boolean provinceStateIsnotnull;

  /**
   * 省/州(精确搜索)
   */
  private List<String> provinceStateInList;

  /**
   * 区/县(模糊搜索)
   */
  private String districtCounty;

  /**
   * 区/县 比较(eq)
   */
  private String districtCountyEq;
  /**
   * 区/县 比较(neq)
   */
  private String districtCountyNeq;
  /**
   * 区/县 比较(gt)
   */
  private String districtCountyGt;
  /**
   * 区/县 比较(gte)
   */
  private String districtCountyGte;
  /**
   * 区/县 比较(lt)
   */
  private String districtCountyLt;
  /**
   * 区/县 比较(lte)
   */
  private String districtCountyLte;
  /**
   * 区/县 比较(contains)
   */
  private String districtCountyContains;
  /**
   * 区/县 比较(notcontains)
   */
  private String districtCountyNotcontains;
  /**
   * 区/县 比较(startswith)
   */
  private String districtCountyStartswith;
  /**
   * 区/县 比较(endswith)
   */
  private String districtCountyEndswith;
  /**
   * 区/县 比较(isnull)
   */
  private Boolean districtCountyIsnull;
  /**
   * 区/县 比较(isnotnull)
   */
  private Boolean districtCountyIsnotnull;

  /**
   * 区/县(精确搜索)
   */
  private List<String> districtCountyInList;

  /**
   * 门牌号(模糊搜索)
   */
  private String houseNumber;

  /**
   * 门牌号 比较(eq)
   */
  private String houseNumberEq;
  /**
   * 门牌号 比较(neq)
   */
  private String houseNumberNeq;
  /**
   * 门牌号 比较(gt)
   */
  private String houseNumberGt;
  /**
   * 门牌号 比较(gte)
   */
  private String houseNumberGte;
  /**
   * 门牌号 比较(lt)
   */
  private String houseNumberLt;
  /**
   * 门牌号 比较(lte)
   */
  private String houseNumberLte;
  /**
   * 门牌号 比较(contains)
   */
  private String houseNumberContains;
  /**
   * 门牌号 比较(notcontains)
   */
  private String houseNumberNotcontains;
  /**
   * 门牌号 比较(startswith)
   */
  private String houseNumberStartswith;
  /**
   * 门牌号 比较(endswith)
   */
  private String houseNumberEndswith;
  /**
   * 门牌号 比较(isnull)
   */
  private Boolean houseNumberIsnull;
  /**
   * 门牌号 比较(isnotnull)
   */
  private Boolean houseNumberIsnotnull;

  /**
   * 门牌号(精确搜索)
   */
  private List<String> houseNumberInList;

  /**
   * 是否操作库存
   */
  private String isOperation;

  /**
   * 是否操作库存 比较(eq)
   */
  private String isOperationEq;
  /**
   * 是否操作库存 比较(neq)
   */
  private String isOperationNeq;
  /**
   * 是否操作库存 比较(gt)
   */
  private String isOperationGt;
  /**
   * 是否操作库存 比较(gte)
   */
  private String isOperationGte;
  /**
   * 是否操作库存 比较(lt)
   */
  private String isOperationLt;
  /**
   * 是否操作库存 比较(lte)
   */
  private String isOperationLte;
  /**
   * 是否操作库存 比较(contains)
   */
  private String isOperationContains;
  /**
   * 是否操作库存 比较(notcontains)
   */
  private String isOperationNotcontains;
  /**
   * 是否操作库存 比较(startswith)
   */
  private String isOperationStartswith;
  /**
   * 是否操作库存 比较(endswith)
   */
  private String isOperationEndswith;
  /**
   * 是否操作库存 比较(isnull)
   */
  private Boolean isOperationIsnull;
  /**
   * 是否操作库存 比较(isnotnull)
   */
  private Boolean isOperationIsnotnull;

  /**
   * 是否操作库存(精确搜索)
   */
  private List<String> isOperationInList;

  /**
   * 仓库名称(模糊搜索)
   */
  private String wName;

  /**
   * 仓库名称 比较(eq)
   */
  private String wNameEq;
  /**
   * 仓库名称 比较(neq)
   */
  private String wNameNeq;
  /**
   * 仓库名称 比较(gt)
   */
  private String wNameGt;
  /**
   * 仓库名称 比较(gte)
   */
  private String wNameGte;
  /**
   * 仓库名称 比较(lt)
   */
  private String wNameLt;
  /**
   * 仓库名称 比较(lte)
   */
  private String wNameLte;
  /**
   * 仓库名称 比较(contains)
   */
  private String wNameContains;
  /**
   * 仓库名称 比较(notcontains)
   */
  private String wNameNotcontains;
  /**
   * 仓库名称 比较(startswith)
   */
  private String wNameStartswith;
  /**
   * 仓库名称 比较(endswith)
   */
  private String wNameEndswith;
  /**
   * 仓库名称 比较(isnull)
   */
  private Boolean wNameIsnull;
  /**
   * 仓库名称 比较(isnotnull)
   */
  private Boolean wNameIsnotnull;

  /**
   * 仓库名称(精确搜索)
   */
  private List<String> wNameInList;

  /**
   * 领星销售出库单ID
   */
  private Integer woId;

  /**
   * 最小领星销售出库单ID
   */
  private Integer woIdMin;

  /**
   * 最大领星销售出库单ID
   */
  private Integer woIdMax;

  /**
   * 领星销售出库单ID 比较(eq)
   */
  private Integer woIdEq;
  /**
   * 领星销售出库单ID 比较(neq)
   */
  private Integer woIdNeq;
  /**
   * 领星销售出库单ID 比较(gt)
   */
  private Integer woIdGt;
  /**
   * 领星销售出库单ID 比较(gte)
   */
  private Integer woIdGte;
  /**
   * 领星销售出库单ID 比较(lt)
   */
  private Integer woIdLt;
  /**
   * 领星销售出库单ID 比较(lte)
   */
  private Integer woIdLte;
  /**
   * 领星销售出库单ID 比较(contains)
   */
  private Integer woIdContains;
  /**
   * 领星销售出库单ID 比较(notcontains)
   */
  private Integer woIdNotcontains;
  /**
   * 领星销售出库单ID 比较(startswith)
   */
  private Integer woIdStartswith;
  /**
   * 领星销售出库单ID 比较(endswith)
   */
  private Integer woIdEndswith;
  /**
   * 领星销售出库单ID 比较(isnull)
   */
  private Boolean woIdIsnull;
  /**
   * 领星销售出库单ID 比较(isnotnull)
   */
  private Boolean woIdIsnotnull;

  /**
   * 卖家邮箱(模糊搜索)
   */
  private String buyerEmail;

  /**
   * 卖家邮箱 比较(eq)
   */
  private String buyerEmailEq;
  /**
   * 卖家邮箱 比较(neq)
   */
  private String buyerEmailNeq;
  /**
   * 卖家邮箱 比较(gt)
   */
  private String buyerEmailGt;
  /**
   * 卖家邮箱 比较(gte)
   */
  private String buyerEmailGte;
  /**
   * 卖家邮箱 比较(lt)
   */
  private String buyerEmailLt;
  /**
   * 卖家邮箱 比较(lte)
   */
  private String buyerEmailLte;
  /**
   * 卖家邮箱 比较(contains)
   */
  private String buyerEmailContains;
  /**
   * 卖家邮箱 比较(notcontains)
   */
  private String buyerEmailNotcontains;
  /**
   * 卖家邮箱 比较(startswith)
   */
  private String buyerEmailStartswith;
  /**
   * 卖家邮箱 比较(endswith)
   */
  private String buyerEmailEndswith;
  /**
   * 卖家邮箱 比较(isnull)
   */
  private Boolean buyerEmailIsnull;
  /**
   * 卖家邮箱 比较(isnotnull)
   */
  private Boolean buyerEmailIsnotnull;

  /**
   * 卖家邮箱(精确搜索)
   */
  private List<String> buyerEmailInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
